//----------------------------------------------------------------------------
// File: C3DTools.h
// Class: C3DTools
// Type: 3D API Tools Management
// Author: Ken Anderson	
// Date:  10/26/04
// Desc: Provides a set of tools for the renderers.  A function may be directly
//		 linked to a renderer or contain code depending on whether one renderer
//       supports it or not.  OpenGL for example may not support a feature that
//		 Direct3d does, thus a function will directly called Direct3d rather than
//		 contain its own code.
// Required headers: 
// 1. C3DTypes.h == Common elements that belong in a 3d world allowing it to be
//					rendered in 3d, such as lights, vertices, matricies and so forth.
// 2. C3DVector.h == Provides functionality to the vector class.
// 3. C3DMath.h == Provides mathematical definitions.
// 4. D3DTools.h == Required to access the D3D side of tools.
//----------------------------------------------------------------------------

#ifndef __C3DTOOLS__
#define __C3DTOOLS__

#include "CRSDefs.h"
#include "C3DTypes.h"
#include "C3DVector.h"
#include "C3DMath.h"
#include "D3DTools.h"

class C3DTools
{
private:
	D3DTools* m_pD3D;
	OGLTools* m_pOGL;
	RendererType m_Renderer;

public:
	C3DTools(RendererType RT);
	C3DTools(const C3DTools& tools);
	~C3DTools();

	C3DERR SetRenderer(RendererType RT);

	//REMOVE LATER
	C3DMatrix* DMTCM(C3DMatrix* pM1, D3DXMATRIX* pM2);
	D3DXMATRIX* CMTDM(D3DXMATRIX* pM1, const C3DMatrix* pM2);

	//NOTE:  Inline may cause errors
	//2-Dimensional Vectors
	void Vec2Minimize( C3DVector2& rOut, const C3DVector2& rV1, const C3DVector2& rV2);
	void Vec2Maximize( C3DVector2& rOut, const C3DVector2& rV1, const C3DVector2& rV2);
	void Vec2Lerp( C3DVector2& rOut, const C3DVector2& rV1, const C3DVector2& rV2, float s);
	float Vec2CCW(const C3DVector2& rV1, const C3DVector2& rV2);
	float Vec2Dot(const C3DVector2& rV1, const C3DVector2& rV2);

	//3-Dimensional Vectors	
	float Vec3Dot(const C3DVector3& rV1, const C3DVector3& rV2);
	void Vec3Cross(C3DVector3& rOut, const C3DVector3& rV1, const C3DVector3& rV2);
	void Vec3Minimize(C3DVector3& rOut, const C3DVector3& rV1, const C3DVector3& rV2);
	void Vec3Maximize(C3DVector3& rOut, const C3DVector3& rV1, const C3DVector3& rV2);
	void Vec3Lerp(C3DVector3& rOut, const C3DVector3& rV1, const C3DVector3& rV2, float s);

	//4-Dimensional Vectors
	float Vec4Dot(C3DVector4* pV1, C3DVector4* pV2);
	C3DVector4* Vec4Minimize(C3DVector4* pOut, const C3DVector4* pV1, const C3DVector4* pV2);
	C3DVector4* Vec4Maximize(C3DVector4* pOut, const C3DVector4* pV1, const C3DVector4* pV2);
	C3DVector4* Vec4Lerp(C3DVector4* pOut, const C3DVector4* pV1, const C3DVector4* pV2, float s);

	void MatrixZero(C3DMatrix& rOut);
	void MatrixAdd(C3DMatrix& rOut, const C3DMatrix& rM1, const C3DMatrix& rM2);
	void MatrixSubtract(C3DMatrix& rOut, const C3DMatrix& rM1, const C3DMatrix& rM2);
	void MatrixScalar(C3DMatrix& rOut, const C3DMatrix& rM1, const float fScale);
	void MatrixIdentity(C3DMatrix& rMatrix);
	bool MatrixIsIdentity(const C3DMatrix& rMatrix);

	C3DMatrix* MatrixInverse(C3DMatrix* pMatrix, float* pfDeterminant, const C3DMatrix* pM);
	float MatrixDeterminant(const C3DMatrix* pMatrix);
	C3DMatrix* MatrixRotationX(C3DMatrix* pMatrix, float fAngle);
	C3DMatrix* MatrixRotationY(C3DMatrix* pMatrix, float fAngle);
	C3DMatrix* MatrixRotationZ(C3DMatrix* pMatrix, float fAngle);
	C3DMatrix* MatrixTranslation(C3DMatrix* pMatrix, float x, float y, float z);
	C3DMatrix* MatrixScaling(C3DMatrix* pMatrix, float x, float y, float z);

	C3DMatrix* MatrixLookAtLH(C3DMatrix* pMatrix, C3DVector3* pEye, C3DVector3* pAt, C3DVector3* pUp);
	C3DMatrix* MatrixLookAtRH(C3DMatrix* pMatrix, C3DVector3* pEye, C3DVector3* pAt, C3DVector3* pUp);
	C3DMatrix* MatrixPerspectiveFovLH(C3DMatrix* pMatrix, float fFOV, float fAspect, float fNear, float fFar);
	C3DMatrix* MatrixPerspectiveFovRH(C3DMatrix* pMatrix, float fFOV, float fAspect, float fNear, float fFar);
	C3DMatrix* MatrixMultiply(C3DMatrix* pMatrix, const C3DMatrix* pM1, const C3DMatrix* pM2);

	/*
	//Renderer Specific tools
	 C3DVector2* Vec2BaryCentric(C3DVector2* pOut, const C3DVector2* pV1, const C3DVector2* pV2, const C3DVector2* pV3, float f, float g);
	 C3DVector2* Vec2CatmullRom(C3DVector2* pOut, const C3DVector2* pV1, const C3DVector2* pV2, const C3DVector2* pV3, const C3DVector2* pV4, float s);
	 C3DVector2* Vec2Hermite(C3DVector2* pOut, const C3DVector2* pV1, const C3DVector2* pT1, const C3DVector2* pV2, const C3DVector2* pT2, float s);
	 C3DVector4* Vec2Transform(C3DVector4** pOut, const C3DVector2* pV, const C3DMatrix* pM);
	 C3DVector4* Vec2TransformCoord(C3DVector2* pOut, const C3DVector2* pV, const C3DMatrix* pM);
	 C3DVector4* Vec2TransformNormal(C3DVector2* pOut, const C3DVector2* pV, const C3DMatrix* pM);
	
	 C3DVector3* Vec3BaryCentric(C3DVector3* pOut, const C3DVector3* pV1, const C3DVector3* pV2, const C3DVector3* pV3, float f, float g);
	 C3DVector3* Vec3CatmullRom(C3DVector3* pOut, const C3DVector3* pV1, const C3DVector3* pV2, const C3DVector3* pV3, const C3DVector3* pV4, float s);
	 C3DVector3* Vec3Hermite(C3DVector3* pOut, const C3DVector3* pV1, const C3DVector3* pT1, const C3DVector3* pV2, const C3DVector3* pT2, float s);
	// C3DVector3* Vec3Project(C3DVector3* pOut, const C3DVector3* pV, 
	 C3DVector4* Vec3Transform(C3DVector4** pOut, const C3DVector3* pV, const C3DMatrix* pM);
	 C3DVector4* Vec3TransformCoord(C3DVector3* pOut, const C3DVector3* pV, const C3DMatrix* pM);
	 C3DVector4* Vec3TransformNormal(C3DVector3* pOut, const C3DVector3* pV, const C3DMatrix* pM);
	// C3DVector3* Vec3Unproject
	
	 C3DVector4* Vec4BaryCentric(C3DVector4* pOut, const C3DVector4* pV1, const C3DVector4* pV2, const C3DVector4* pV3, float f, float g);
	 C3DVector4* Vec4CatmullRom(C3DVector4* pOut, const C3DVector4* pV1, const C3DVector4* pV2, const C3DVector4* pV3, const C3DVector2* pV4, float s);
	 C3DVector4* Vec4Cross(C3DVector4* pOut, const C3DVector4* pV1, const C3DVector4* pV2, const C3DVector4* pV3);
	 C3DVector4* Vec4Hermite(C3DVector4* pOut, const C3DVector4* pV1, const C3DVector4* pT1, const C3DVector4* pV2, const C3DVector4* pT2, float s);
	 C3DVector4* Vec4Transform(C3DVector4* pOut, const C3DVector4* pV, const C3DMatrix* pM);
	 */
};

#endif